import fetch from 'node-fetch';
import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import { dirname } from 'path';
import MD5 from 'md5';
import { confg } from './constant.js';
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
//使用方法
// node ./translate.js src/pages/user
// 百度翻译配置
const BAIDU_APP_ID = confg.BAIDU_APP_ID;
const BAIDU_SECRET_KEY = confg.BAIDU_SECRET_KEY;

// 获取命令行参数
const sourcePath = process.argv[2];
if (!sourcePath) {
  console.error('请提供要翻译的文件夹路径！');
  console.log('使用方法: node translate-script.js <文件夹路径>');
  process.exit(1);
}

// 获取项目根目录
const projectRoot = path.resolve(__dirname, '../..');

// 将命令行参数转换为绝对路径
const sourceDir = path.resolve(projectRoot, sourcePath);
const i18nFile = path.join(projectRoot, 'i18n/lang/zh.json');

// 支持的文件类型
const SUPPORTED_EXTENSIONS = ['.vue', '.js', '.ts', '.jsx', '.tsx'];

// 读取现有的翻译文件
async function readExistingTranslations() {
  try {
    const content = fs.readFileSync(i18nFile, 'utf8');
    return JSON.parse(content);
  } catch (error) {
    return {};
  }
}

// 提取中文文本，支持更多场景
function extractChineseText(content) {
  // 修改正则表达式以匹配包含标点符号的完整中文短语
  const chineseRegex = /[\u4e00-\u9fa5，。！？、]+/g;
  const matches = content.match(chineseRegex) || [];
  return [...new Set(matches)]; // 去重
}

// 转换为 kebab-case (横杠连接)
function toKebabCase(str) {
  return str
    .toLowerCase()
    // 将空格、下划线和逗号替换为横杠
    .replace(/[\s_,]+/g, '-')
    // 在大写字母前添加横杠
    .replace(/([a-z])([A-Z])/g, '$1-$2')
    .toLowerCase()
    // 移除特殊字符
    .replace(/[^a-z0-9-]/g, '')
    // 移除多余的横杠
    .replace(/-+/g, '-')
    // 移除首尾的横杠
    .replace(/^-|-$/g, '');
}

// 添加延时函数
function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// 翻译中文到英文
async function translateToEnglish(text) {
  try {
    const salt = new Date().getTime();
    const sign = MD5(BAIDU_APP_ID + text + salt + BAIDU_SECRET_KEY);
    
    const response = await fetch('http://api.fanyi.baidu.com/api/trans/vip/translate', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
      },
      body: new URLSearchParams({
        q: text,
        from: 'zh',
        to: 'en',
        appid: BAIDU_APP_ID,
        salt: salt,
        sign: sign
      })
    });

    const result = await response.json();
    
    if (result.error_code) {
      throw new Error(`百度翻译错误: ${result.error_msg}`);
    }

    const translatedText = result.trans_result[0].dst;
    console.log(`翻译结果: ${text} -> ${translatedText}`);
    
    // 使用 kebab-case 替代 camelCase
    return toKebabCase(translatedText);
  } catch (error) {
    console.error(`翻译失败: ${text}`, error);
    // 基础映射表作为后备方案
    const fallbackMap = {
      '用户': 'user',
      '角色': 'role',
      '登录': 'login',
      '注册': 'register',
      '密码': 'password',
      '设置': 'settings',
      '管理': 'manage',
      '列表': 'list'
    };
    return fallbackMap[text] || `key-${MD5(text).substr(0, 8)}`;
  }
}

// 处理单个文件
async function processFile(filePath, translations) {
  console.log(`正在处理文件: ${filePath}`);
  const content = fs.readFileSync(filePath, 'utf8');
  const chineseTexts = extractChineseText(content);
  
  const relativePath = path.relative(projectRoot, filePath);
  const pathParts = relativePath.split(path.sep);
  const pagesIndex = pathParts.indexOf('pages');
  const parentDir = pagesIndex >= 0 && pathParts[pagesIndex + 1] 
    ? pathParts[pagesIndex + 1] 
    : 'common';

  if (!translations[parentDir]) {
    translations[parentDir] = {};
  }

  // 创建一个反向映射，用于快速查找已存在的中文翻译
  const reverseTranslations = {};
  for (const section in translations) {
    for (const [key, value] of Object.entries(translations[section])) {
      reverseTranslations[value] = key;
    }
  }

  // 逐个处理每个中文文本
  for (const text of chineseTexts) {
    if (!text.trim()) continue;
    
    // 检查这个中文是否已经有对应的翻译
    if (reverseTranslations[text]) {
      const existingKey = reverseTranslations[text];
      console.log(`使用已存在的翻译: ${text} -> ${existingKey}`);
      translations[parentDir][existingKey] = text;
    } else {
      // 只有在没有找到已存在翻译时，才调用翻译API
      const translatedText = await translateToEnglish(text);
      translations[parentDir][translatedText] = text;
      console.log(`新增翻译: ${text} -> ${translatedText}`);
      // 更新反向映射
      reverseTranslations[text] = translatedText;
    }
  }

  return translations;
}

// 递归处理目录
async function processDirectory(dir, translations) {
  const files = fs.readdirSync(dir);
  
  for (const file of files) {
    const fullPath = path.join(dir, file);
    const stat = fs.statSync(fullPath);
    
    if (stat.isDirectory()) {
      await processDirectory(fullPath, translations);
    } else if (SUPPORTED_EXTENSIONS.includes(path.extname(fullPath))) {
      await processFile(fullPath, translations);
    }
  }
}

// 主函数
async function main() {
  try {
    // 验证源目录是否存在
    if (!fs.existsSync(sourceDir)) {
      console.error(`目录不存在: ${sourceDir}`);
      process.exit(1);
    }

    console.log(`开始处理目录: ${sourceDir}`);
    console.log(`项目根目录: ${projectRoot}`);
    
    // 列出目录中的文件
    const files = fs.readdirSync(sourceDir);
    console.log(`目录中的文件:`, files);

    // 确保i18n目录存在
    const i18nDir = path.dirname(i18nFile);
    if (!fs.existsSync(i18nDir)) {
      fs.mkdirSync(i18nDir, { recursive: true });
    }

    // 读取现有翻译
    const translations = await readExistingTranslations();
 

    // 处理所有文件
    await processDirectory(sourceDir, translations);

    // 写入文件
    fs.writeFileSync(i18nFile, JSON.stringify(translations, null, 2), 'utf8');
    console.log('翻译完成！');

  } catch (error) {
    console.error('发生错误:', error);
    process.exit(1);
  }
}

// 运行脚本
main();